package com.koron.device.controller;


import cn.afterturn.easypoi.excel.ExcelImportUtil;
import cn.afterturn.easypoi.excel.entity.ImportParams;
import cn.afterturn.easypoi.excel.entity.result.ExcelImportResult;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.StrUtil;
import com.koron.bean.base.Response;
import com.koron.bean.standard.deviceClasssify.po.Type;
import com.koron.bean.system.staff.vo.EamUser;
import com.koron.common.core.config.ThreadLocalContext;
import com.koron.common.core.util.CodeTools;
import com.koron.common.core.util.CommonUtils;
import com.koron.common.core.util.DateAndTimeUtils;
import com.koron.common.core.util.ExportExcelUtil;
import com.koron.device.bean.EquipmentLocation;
import com.koron.device.bean.EquipmentParams;
import com.koron.device.bean.Select;
import com.koron.device.bean.TGParams;
import com.koron.device.bean.bo.BaseImpData;
import com.koron.device.bean.bo.EqComposeBo;
import com.koron.device.bean.bo.TypeParamCompose;
import com.koron.device.bean.bo.TypeParamsJs;
import com.koron.device.bean.template.*;
import com.koron.device.mapper.TypeParamsMapper;
import com.koron.device.service.ParamimpService;
import com.koron.device.service.impl.EquipmentServiceImpl;
import com.koron.device.utils.EqExportOrImpUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.usermodel.Workbook;
import org.koron.ebs.mybatis.ADOConnection;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.util.*;
import java.util.function.Function;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

@Slf4j
@RestController
@Api(tags = "EAM台账参数导出导入")
@RequestMapping("/paramimp")
public class ParamimpController {

    private EamUser getCurrUser() {
        return ThreadLocalContext.get();
    }

    private String getCurDs() {
        return ThreadLocalContext.get().getCurrDs();
    }

    @Autowired
    private EquipmentServiceImpl equipmentservice;


    /**
     * 导入
     *
     * @param file
     * @return
     * @throws Exception
     */
    @ApiOperation(value = "设备基础参数导入")
    @PostMapping("/importRecord")
    public Response importRecord(@RequestParam("file") MultipartFile file,
                                 @RequestParam(value = "groupId", defaultValue = "d623079fafee452fadb4779acb7b7612") String groupId,
                                 @RequestParam(value = "groupName", defaultValue = "设备（常规）") String groupName,
                                 HttpServletResponse response) throws Exception {
        //业务代码 查询计划 模板下的维度以及维度下的动态列
        List<TGParams> impTgParams = ADOConnection.runTask(getCurDs(), factory -> {
            List<TGParams> tgParams = factory.getMapper(TypeParamsMapper.class).queryByGroupId(groupId);
            tgParams.stream().forEach(f -> {
                f.setParamName(CommonUtils.englishtoCamelCase(f.getParamName()));// 英文参数转驼峰
            });
            return tgParams;
        }, List.class);

        List<TemplateDimensionDto> templateDimensionDtos = new ArrayList<>();
        //导入参数
        ImportParams impParams = new ImportParams();
        //读取的sheet开始角标 默认0
        impParams.setStartSheetIndex(0);
//            params.setSheetNum(1 + i);
        //处理每个sheet页中的动态列
        List<DynamicColumnVo> initColum = ExportExcelMsg.getInitColum();
        List<DynamicColumnVo> collect = new ArrayList<>();
        for (TGParams tgp : impTgParams) {
            if (tgp.getParamName().equals("安装位置")) {
                collect.add(new DynamicColumnVo("安装位置名称", "安装位置名称"));
                collect.add(new DynamicColumnVo("安装位置完整路径", "安装位置完整路径"));
                continue;
            }
            collect.add(new DynamicColumnVo(tgp.getParamName(), tgp.getParamName()));
        }
        // 最终要识别的列
        initColum = CollUtil.unionAll(initColum, collect);
        // 检查是否有不可识别列
        chekNotImpColumn(file, groupName, initColum);
        // 识别导入数据
        List<?> result = ExcelImportUtil.importExcel(file.getInputStream(), EqExportOrImpUtils.generatePrototypeClass(initColum), impParams);
        // 处理导入数据变成可用的数据
        List<Map<String, String>> implist = EqExportOrImpUtils.parseObjectList(result);

        Assert.isFalse(CollUtil.isEmpty(implist), "没有可导入的数据");

        List<String> impEqId = implist.stream().map(m -> {
            return m.get("设备id");
        }).collect(Collectors.toList());

        // 要导入参数的设备
        EqComposeBo eqcomposebo = ADOConnection.runTask(getCurDs(), factory -> {
            return equipmentservice.getEqComposeBo(impEqId, factory);
        }, EqComposeBo.class);

        // 品牌 、人员、组织
        BaseImpData baseimpdata = ADOConnection.runTask(factory -> {
            return equipmentservice.getBaseImpData(factory);
        }, BaseImpData.class);

        // 匹配 设备分类 对应的 参数集
        List<TypeParamCompose> typeparamcomposelist = ADOConnection.runTask(factory -> {
            return equipmentservice.getTypeParamComposes(factory);
        }, List.class);


        // 人员
        Map<String, String> usermap = baseimpdata.getUsermap();
        Map<String, String> userAccNamemap = baseimpdata.getUserAccNamemap();

        // 组织
        Map<String, String> orgmap = baseimpdata.getOrgmap();

        // 分类id-基础参数列表 map
        Map<String, List<TGParams>> typeIdtgpmap = typeparamcomposelist.stream().collect(Collectors.toMap(Type::getId, new Function<TypeParamCompose, List<TGParams>>() {
            @Override
            public List<TGParams> apply(TypeParamCompose typeParamCompose) {
                return typeParamCompose.getTgplist();
            }
        }));

        // 分类id-技术参数列表 map
        Map<String, List<TypeParamsJs>> typeIdjsParamap = typeparamcomposelist.stream().collect(Collectors.toMap(Type::getId, new Function<TypeParamCompose, List<TypeParamsJs>>() {
            @Override
            public List<TypeParamsJs> apply(TypeParamCompose typeParamCompose) {
                return typeParamCompose.getTpjslist();
            }
        }));

        //设备id-设备分类id map
        Map<String, String> eqidTypeIdtemp = eqcomposebo.getEqidTypeIdtemp();

        // 表格设备的所有参数
        List<EquipmentParams> impEquipmentParams = eqcomposebo.getEquipmentParams();
        // Map<String, EquipmentParams> paramIdObjemap = impEquipmentParams.stream().collect(Collectors.toMap(EquipmentParams::getId, item -> item));

        // 所有位置信息  位置全路径-位置id
        List<EquipmentLocation> locationlist = eqcomposebo.getLocationlist();
//        Map<String, String> locationIdandNamemap = locationlist.stream().collect(Collectors.toMap(EquipmentLocation::getId, EquipmentLocation::getName));
        Map<String, String> locationIdandNamemap = locationlist.stream().collect(Collectors.toMap(EquipmentLocation::getFullPathName, EquipmentLocation::getId));

        List<EquipmentParams> updatelist = new ArrayList();
        List<EquipmentParams> insertlist = new ArrayList();

        // 遍历表格每一行
        for (int i = 0; i < implist.size(); i++) {
            Map<String, String> imp = implist.get(i);

            // 列名
            Set<String> fields = imp.keySet();

            if (MapUtil.isEmpty(imp) || i == 0) {
                continue;
            }

            // 设备id
            String eqId = "";
            // 设备分类 id
            String eqTypeId = "";
            // 设备已有参数集合  后续工作 依据此集合 判断增加 updatelist、insertlist 集合
            List<EquipmentParams> existEqParamlist = new ArrayList<>();
            // 设备对应的基础参数集合
            List<TGParams> typegroupparamslist = new ArrayList<>();
            // 设备对应的技术参数集合
            List<TypeParamsJs> typeparamsjslist = new ArrayList<>();
            Map<String, String> impparammap = new HashMap();
            for (String paramName : fields) {
                String paramValue = imp.get(paramName);
                if (StrUtil.isNotBlank(paramValue)) {
                    if (paramName.equals("设备id")) {
                        // 节省一次遍历
                        eqId = paramValue;
                        eqTypeId = eqidTypeIdtemp.get(eqId);
                        if (StrUtil.isBlank(eqTypeId)) {
                            continue;   // 获取不到设备类型标识该设备是虚拟节点
                        }
                        typegroupparamslist = typeIdtgpmap.get(eqTypeId); // 基础参数
                        String finalEqId = eqId; // 嫁接一下
                        existEqParamlist = impEquipmentParams.stream().filter(im -> im.getEquipmentId().equals(finalEqId)).collect(Collectors.toList());
                    }
                    impparammap.put(paramName, paramValue);
                }
            }

            if (StrUtil.isBlank(eqId)) {
                imp.put(errorMsgStr, StrUtil.format("{}行：缺少设备id", i + 1));
                continue;
            }


            Set<String> paramNameset = impparammap.keySet();
            // ∵遍历设备所拥有的 基础参数集合
            // ∴filter出要导入的参数集合
            // ∴等价于 遍历表格行内的所有列
            typegroupparamslist = typegroupparamslist.stream().filter(ty -> ty != null && Objects.equals(ty.getGroupId(), groupId)).collect(Collectors.toList());
            for (TGParams cdbprarm : typegroupparamslist) {
                EquipmentParams tempparam = new EquipmentParams();
                // 参数表：安装位置 匹配 表格：安装位置完整路径
                if (cdbprarm.getParamName().equals("安装位置")) {
                    cdbprarm.setParamName("安装位置完整路径");
                }
                if (!paramNameset.contains(cdbprarm.getParamName())) {
                    continue;
                }
                tempparam.setId(CodeTools.getCode32());
                tempparam.setDataSources(DateUtil.now() + "-参数导入-" + file.getResource().getFilename());
                tempparam.setEquipmentId(eqId);
                tempparam.setParamId(cdbprarm.getId());
                // 真实参数
                String param = StrUtil.trim(impparammap.get(cdbprarm.getParamName()));

                // 处理数据 参数类型 单选、多选、位置、组织、人员、文本框
                if (handleImpDate(i + 1, usermap, userAccNamemap, orgmap, locationIdandNamemap, imp, cdbprarm, tempparam, param))
                    continue;

                Map<String, EquipmentParams> paramIdObjemap = existEqParamlist.stream().collect(Collectors.toMap(EquipmentParams::getParamId, item -> item));
                // 设备是否已存在 该参数
                if (paramIdObjemap.containsKey(cdbprarm.getId())) {
                    // 获取已存在参数记录id，赋值给tempparam
                    EquipmentParams equipmentParams = paramIdObjemap.get(cdbprarm.getId());
                    tempparam.setId(equipmentParams.getId());
                    updatelist.add(tempparam);
                } else {
                    // 设备不存在参数记录 直接添加
                    insertlist.add(tempparam);
                }

            } // 遍历 行内每列 结束


            String jsparams = impparammap.get("技术参数");
            HashMap<String, String> impjsmap = new HashMap<>();
            if (StrUtil.isNotBlank(jsparams)) {
                List<String> jsunits = StrUtil.split(jsparams, ';');
                for (String jsunit : jsunits) {
                    List<String> split = StrUtil.split(jsunit, ':');
                    if (split.size() == 2) {
                        impjsmap.put(split.get(0), split.get(1));
                    }
                }
            }

        }// 遍历表格每行 结束

        List<Map<String, String>> errmsglist = implist.stream().filter(m -> StrUtil.isNotBlank(m.get(errorMsgStr))).collect(Collectors.toList());

        log.debug(StrUtil.format("更新参数数据：{}条"), updatelist.size());
        log.debug(StrUtil.format("新增参数数据：{}条"), insertlist.size());

        if (CollUtil.isNotEmpty(errmsglist)) {
            ImPMsgDto imPMsgDto = new ImPMsgDto("ERROR", "导入更新异常", null);
            List<String> numMsg = errmsglist.stream().map(m -> m.get(errorMsgStr)).collect(Collectors.toList());
            String servecFilePath = ADOConnection.runTask(getCurDs(), factory -> {
                Workbook sheet = equipmentservice.getSheets(null, implist, groupId, factory);
                return ExportExcelUtil.savedExcelFile(sheet, file.getResource().getFilename());
            }, String.class);
            numMsg.stream().forEach(System.out::println);
            imPMsgDto.setErrMsglist(numMsg);
            imPMsgDto.setFileName(servecFilePath);
            return Response.ok(imPMsgDto);
        }

        if (CollUtil.isEmpty(updatelist) && CollUtil.isEmpty(insertlist)) {
            return Response.ok("无数据导入");
        }

        // 保存设备参数
        ADOConnection.runTask(getCurDs(), factory -> {
            equipmentservice.batchSaveEquipemntParams(updatelist, insertlist, factory);
            return true;
        }, Boolean.class);

        return Response.ok(new ImPMsgDto("SUCCESS", "导入更新成功", null));
    }

    /**
     * 检查是否有不可识别列
     *
     * @param file      导入文件
     * @param groupName 参数组名称
     * @param initColum 可识别列
     */
    private void chekNotImpColumn(MultipartFile file, String groupName, List<DynamicColumnVo> initColum) {
        LinkedHashSet<String> checkColumn = EqExportOrImpUtils.getTopRow(file, file.getResource().getFilename(), 0);
        List<String> notImpColumn = new ArrayList<>();
        for (String check : checkColumn) {
            if (StrUtil.isBlank(check)) {
                continue;
            }
            String converCheck = CommonUtils.englishtoCamelCase(check); // 表格英文参数列转化驼峰参数 Seial no => seialNo
            Optional<String> first = initColum.stream().map(DynamicColumnVo::getField).filter(f -> f.equals(converCheck)).findFirst();
            if (!first.isPresent()) {
                notImpColumn.add(check);
            }
        }
        if (CollUtil.isNotEmpty(notImpColumn)) {
            String errstr = notImpColumn.stream().collect(Collectors.joining("、"));
            Assert.isFalse(true, StrUtil.format("{}参数组不能识别:{} 列", groupName, errstr));
        }
    }

    public static String errorMsgStr = "错误信息";

    /**
     * 基础参数、技术参数 的 参数类型都在这里判断 赋值
     *
     * @param num                  行数
     * @param usermap              人员名称-人员账号 map
     * @param userAccNamemap       人员账号-人员名称 map
     * @param orgmap               组织名称-组织id map
     * @param locationIdandNamemap 位置id-位置名称 map
     * @param imp                  表格每行数据
     * @param cdbprarm             参数信息
     * @param tempparam            临时中间单元
     * @param param                表格参数
     * @return
     */
    private boolean handleImpDate(int num,
                                  Map<String, String> usermap,
                                  Map<String, String> userAccNamemap,
                                  Map<String, String> orgmap,
                                  Map<String, String> locationIdandNamemap,
                                  Map<String, String> imp, TGParams cdbprarm,
                                  EquipmentParams tempparam,
                                  String param) {
        // 参数是单选 或 多选 类型
        List<Select> paramlist = cdbprarm.getParamlist();
        if (CollUtil.isNotEmpty(paramlist)) {
            List<String> valuelist = paramlist.stream().map(Select::getValue).collect(Collectors.toList());
            // 没有维护参数选项
            if (CollUtil.isEmpty(valuelist)) {
                return true;
            }
            Map<String, String> labelValuemap = paramlist.stream().collect(Collectors.toMap(Select::getLabel, Select::getValue));
            // 输入类型（radio,单选；multi，多选；box，文本框）
            if (cdbprarm.getEnterType().equals("radio")) {
                if (StrUtil.isBlank(labelValuemap.get(param))) {
                    imp.put(errorMsgStr, StrUtil.format("{}行：{} 列找不到：{} 对应的选项", num + 1, cdbprarm.getParamName(), param));
//                    imp.setErrorMsg(imp.getRowNum() + "行" + cdbprarm.getParamName() + " 列找不到：" + param + "对应的选项");
                    return true;
                }
                tempparam.setParamValue(param);
                tempparam.setParamResult(labelValuemap.get(param));
            }
            // 多选用下标一一对应
            if (cdbprarm.getEnterType().equals("multi")) {
                List<String> split = StrUtil.split(param, '、');
                List<String> paramstrlist = new ArrayList<>();
                for (String s : split) {
                    if (StrUtil.isBlank(labelValuemap.get(s))) {
                        imp.put(errorMsgStr, StrUtil.format("{}行：{} 列找不到：{} 对应的选项", num + 1, cdbprarm.getParamName(), param));
//                        imp.setErrorMsg(imp.getRowNum() + "行" + cdbprarm.getParamName() + " 列找不到：" + s + " 的对应的选项");
                        continue;
                    }
                    paramstrlist.add(labelValuemap.get(s));
                }
                tempparam.setParamValue(param);
                tempparam.setParamResult(StrUtil.join(",", paramstrlist));
            }
        }

        // 参数是位置信息
        if (cdbprarm.getEnterType().equals("location")) {
            param = StrUtil.trim(param);
            if (!locationIdandNamemap.containsKey(param)) {
                imp.put(errorMsgStr, StrUtil.format("{}行：{} 列定位不到：{} 位置信息", num + 1, cdbprarm.getParamName(), param));
//                imp.setErrorMsg(imp.getRowNum() + "行" + cdbprarm.getParamName() + " 列找不到：" + param + " 位置id");
                return true;
            }
            List<String> split = StrUtil.split(param, "/");
            // 位置参数为空
            if (CollUtil.isEmpty(split)) {
                tempparam.setParamValue("");
                tempparam.setParamResult("");
            } else {
                //位置参参数最后一个分割
                String last = CollUtil.getLast(split);
                tempparam.setParamValue(last);
                tempparam.setParamResult(locationIdandNamemap.get(param));
            }
        }

        // 参数是日期类型
        if (cdbprarm.getEnterType().equals("date_day")) {
            String formatDate = null;
            formatDate = DateAndTimeUtils.converExcelDate(param);
            boolean legalDate = DateAndTimeUtils.isLegalDate(formatDate.length(), formatDate, "yyyy-MM-dd");
//            boolean legalDate = DateUnits.isLegalDate(param.length(), param, "yyyy-MM-dd");
            if (!legalDate) {
                imp.put(errorMsgStr, StrUtil.format("{}行：{} 列 日期格式校验不通过：{}", num + 1, cdbprarm.getParamName(), param));
//                imp.setErrorMsg(imp.getRowNum() + "行" + cdbprarm.getParamName() + " 列找不到：" + param + " 日期格式校验不通过; 转化后仍不及格格式:"+formatDate);
                return true;
            }
            tempparam.setParamValue(formatDate);
            tempparam.setParamResult(formatDate);
        }

        // 参数是日期类型
        if (cdbprarm.getEnterType().equals("date_day")) {
            String formatDate = null;
            formatDate = DateAndTimeUtils.converExcelDate(param);
            boolean legalDate = DateAndTimeUtils.isLegalDate(formatDate.length(), formatDate, "yyyy-MM-dd");
//            boolean legalDate = DateUnits.isLegalDate(param.length(), param, "yyyy-MM-dd");
            if (!legalDate) {
                imp.put(errorMsgStr, StrUtil.format("{}行：{} 列 日期格式校验不通过：{}", num + 1, cdbprarm.getParamName(), param));
//                imp.setErrorMsg(imp.getRowNum() + "行" + cdbprarm.getParamName() + " 列找不到：" + param + " 日期格式校验不通过; 转化后仍不及格格式:\"+formatDate");
                return true;
            }
            tempparam.setParamValue(param);
            tempparam.setParamResult(param);
        }

        // 参数是选人组件
        if (cdbprarm.getEnterType().equals("radio_man")) {
            // 识别为人员账号
            boolean legalDate = param.matches("[a-zA-Z]+");
            if (legalDate || NumberUtil.isNumber(param)) {
                if (!userAccNamemap.containsKey(param)) {
                    imp.put(errorMsgStr, StrUtil.format("{}行：{} 列找不到：{} 账号", num + 1, cdbprarm.getParamName(), param));
//                    imp.setErrorMsg(imp.getRowNum() + "行" + cdbprarm.getParamName() + " 列找不到：" + param + " 账号");
                    return true;
                }
                tempparam.setParamValue(userAccNamemap.get(param));
                tempparam.setParamResult(param);
            }

            // 识别为人员名称
            Pattern p = Pattern.compile("[\u4e00-\u9fa5]");
            if (p.matcher(param).find()) {
                if (!usermap.containsKey(param)) {
                    imp.put(errorMsgStr, StrUtil.format("{}行：{} 列找不到：{} 人员", num + 1, cdbprarm.getParamName(), param));
//                    imp.setErrorMsg(imp.getRowNum() + "行" + cdbprarm.getParamName() + " 列找不到：" + param + " 人员");
                    return true;
                }
                tempparam.setParamValue(param);
                tempparam.setParamResult(userAccNamemap.get(param));
            }
        }

        // 参数是选组织 组件
        if (cdbprarm.getEnterType().equals("radio_org")) {
            if (!orgmap.containsKey(param)) {
                imp.put(errorMsgStr, StrUtil.format("{}行：{} 列找不到：{} 组织", num + 1, cdbprarm.getParamName(), param));
//                imp.setErrorMsg(imp.getRowNum() + "行" + cdbprarm.getParamName() + " 列找不到：" + param + " 组织");
                return true;
            }
            tempparam.setParamValue(param);
            tempparam.setParamResult(orgmap.get(param));
        }

        // 参数是输入框
        if (cdbprarm.getEnterType().equals("box")) {
            if (cdbprarm.getDataType().equals("text")) {
                int limitsize = cdbprarm.getDataLength() == null ? 1000 : cdbprarm.getDataLength(); // 限制长度，数据库长度为1000
                if (param.length() > limitsize) {
                    imp.put(errorMsgStr, StrUtil.format("{}行：{}列 参数过长，长度不能大于:{}", num + 1, cdbprarm.getParamName(), limitsize));
//                    imp.setErrorMsg(imp.getRowNum() + "行" + cdbprarm.getParamName() + " 列 参数过长，长度不能大于 " + limitsize);
                }
                tempparam.setParamValue(param);
                tempparam.setParamResult(param);
            }
            if (cdbprarm.getDataType().equals("number")) {
                if (!NumberUtil.isNumber(param)) {
                    imp.put(errorMsgStr, StrUtil.format("{}行：{}列只能是数字:{}", num + 1, cdbprarm.getParamName(), param));
//                    imp.setErrorMsg(imp.getRowNum() + "行" + cdbprarm.getParamName() + " 列 只能是数字");
                }
                tempparam.setParamValue(param);
                tempparam.setParamResult(param);
            }
        }
        return false;
    }


    @Autowired
    private ParamimpService paramimpservice;

    @ApiOperation(value = "导出技术参数")
    @PostMapping("/exportJsParam")
    public void exportJsParam(HttpServletResponse rsp, @RequestParam(required = false) String eqId) {
        List<EquipmentJsTemplate> listdto = ADOConnection.runTask(getCurDs(), paramimpservice, "exportJsParam", List.class, eqId);
        if (CollUtil.isEmpty(listdto)) {
            return;
        }
        try {
            String eqName = listdto.get(0).getEqName();
            eqName = StrUtil.replace(eqName, ".", "·");
            ExportExcelUtil.exportExcel(listdto, EquipmentJsTemplate.class, eqName + "技术参数", rsp);
        } catch (Exception e) {
            log.error("导出技术参数失败");
            log.error(e.getMessage(), e);
        }
    }

    @ApiOperation(value = "导入技术参数")
    @PostMapping("/importJsParam")
    public Response importJsParam(HttpServletResponse rsp, @RequestParam("file") MultipartFile multipartFile) throws Exception {

        ExcelImportResult<EquipmentJsMsg> result;
        ImportParams params = new ImportParams();
        // 表头设置为2行
        params.setHeadRows(1);
        // 标题行设置为0行，默认是0，可以不设置
        params.setTitleRows(0);
        result = ExcelImportUtil.importExcelMore(multipartFile.getInputStream(), EquipmentJsMsg.class, params);
        List<EquipmentJsMsg> list = result.getList();
        Response response = ADOConnection.runTask(getCurDs(), paramimpservice, "importJsParam", Response.class, list, multipartFile.getResource().getFilename());
        return response;
    }

}
